"""
Excel工具窗口模块 - 完整修复版本
负责Excel数据的导入、处理和配置
"""

import tkinter as tk
from tkinter import ttk, messagebox, filedialog, simpledialog
from typing import List, Dict, Any, Optional, Tuple
import os
import pandas as pd
from datetime import datetime

from core.excel_handler import ExcelHandler
from ui.components.config_dialog import ConfigDialog


class ExcelToolWindow:
    """Excel数据处理工具窗口 - 完整修复版本"""

    def __init__(self, parent, main_app):
        self.main_app = main_app
        self.window = tk.Toplevel(parent)
        self.window.title("Excel数据处理工具 v2.0")
        self.window.geometry("900x700")
        self.window.minsize(800, 600)
        self.window.transient(parent)
        self.window.grab_set()

        # 初始化Excel处理器
        self.excel_handler = ExcelHandler()

        # 数据存储
        self.excel_data = None
        self.df = None
        self.column_names = []
        self.input_configs = []
        self.current_file_path = ""

        # 创建界面
        self.create_widgets()

        # 绑定事件
        self.bind_events()

        # 加载最近的文件
        self.load_recent_files()

    def create_widgets(self):
        """创建界面组件 - 修复版本"""
        # 主框架
        main_frame = ttk.Frame(self.window, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)

        # 创建笔记本（选项卡）
        self.notebook = ttk.Notebook(main_frame)
        self.notebook.pack(fill=tk.BOTH, expand=True, pady=(0, 10))

        # 创建数据导入选项卡
        self.import_tab = ttk.Frame(self.notebook, padding="5")
        self.config_tab = ttk.Frame(self.notebook, padding="5")
        self.preview_tab = ttk.Frame(self.notebook, padding="5")

        self.notebook.add(self.import_tab, text="数据导入")
        self.notebook.add(self.config_tab, text="配置管理")
        self.notebook.add(self.preview_tab, text="数据预览")

        # 创建各选项卡内容
        self.create_import_tab(self.import_tab)
        self.create_config_tab(self.config_tab)
        self.create_preview_tab(self.preview_tab)

        # 按钮区域
        self.create_button_section(main_frame)

        # 状态栏
        self.create_status_bar(main_frame)

    def create_import_tab(self, parent):
        """创建数据导入选项卡"""
        # 文件选择区域
        file_frame = ttk.LabelFrame(parent, text="文件选择", padding="10")
        file_frame.pack(fill=tk.X, pady=(0, 10))

        # 文件路径
        path_frame = ttk.Frame(file_frame)
        path_frame.pack(fill=tk.X, pady=2)

        ttk.Label(path_frame, text="Excel文件:").pack(side=tk.LEFT)
        self.file_path_var = tk.StringVar()
        file_entry = ttk.Entry(path_frame, textvariable=self.file_path_var, width=60)
        file_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)

        ttk.Button(path_frame, text="浏览", command=self.browse_file).pack(side=tk.RIGHT)
        ttk.Button(path_frame, text="刷新", command=self.refresh_file).pack(side=tk.RIGHT, padx=(5, 0))

        # 最近文件区域
        recent_frame = ttk.Frame(file_frame)
        recent_frame.pack(fill=tk.X, pady=2)

        ttk.Label(recent_frame, text="最近文件:").pack(side=tk.LEFT)
        self.recent_files_var = tk.StringVar()
        recent_combo = ttk.Combobox(
            recent_frame,
            textvariable=self.recent_files_var,
            values=[],
            state="readonly",
            width=50
        )
        recent_combo.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
        recent_combo.bind('<<ComboboxSelected>>', self.on_recent_file_selected)

        # 设置选项
        settings_frame = ttk.LabelFrame(parent, text="导入设置", padding="10")
        settings_frame.pack(fill=tk.X, pady=(0, 10))

        # 第一行设置
        row1 = ttk.Frame(settings_frame)
        row1.pack(fill=tk.X, pady=2)

        ttk.Label(row1, text="工作表:").pack(side=tk.LEFT)
        self.sheet_var = tk.StringVar()
        self.sheet_combo = ttk.Combobox(
            row1,
            textvariable=self.sheet_var,
            values=[],
            state="readonly",
            width=20
        )
        self.sheet_combo.pack(side=tk.LEFT, padx=5)
        self.sheet_combo.bind('<<ComboboxSelected>>', self.on_sheet_changed)

        ttk.Label(row1, text="表头行:").pack(side=tk.LEFT, padx=(20, 5))
        self.header_row_var = tk.StringVar(value="1")
        header_spin = ttk.Spinbox(
            row1,
            textvariable=self.header_row_var,
            from_=0, to=100, width=5,
            command=self.on_header_row_changed
        )
        header_spin.pack(side=tk.LEFT)
        header_spin.bind('<FocusOut>', self.on_header_row_changed)

        ttk.Label(row1, text="数据开始行:").pack(side=tk.LEFT, padx=(20, 5))
        self.start_row_var = tk.StringVar(value="2")
        start_spin = ttk.Spinbox(
            row1,
            textvariable=self.start_row_var,
            from_=1, to=1000, width=5
        )
        start_spin.pack(side=tk.LEFT)

        # 第二行设置
        row2 = ttk.Frame(settings_frame)
        row2.pack(fill=tk.X, pady=2)

        ttk.Button(row2, text="加载Excel", command=self.load_excel).pack(side=tk.LEFT, padx=2)
        ttk.Button(row2, text="验证文件", command=self.validate_file).pack(side=tk.LEFT, padx=2)
        ttk.Button(row2, text="文件信息", command=self.show_file_info).pack(side=tk.LEFT, padx=2)

        # 文件信息显示
        info_frame = ttk.LabelFrame(parent, text="文件信息", padding="10")
        info_frame.pack(fill=tk.X)

        self.file_info_text = tk.Text(info_frame, height=6, wrap=tk.WORD, state=tk.DISABLED)
        scrollbar = ttk.Scrollbar(info_frame, orient=tk.VERTICAL, command=self.file_info_text.yview)
        self.file_info_text.configure(yscrollcommand=scrollbar.set)

        self.file_info_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

    def create_config_tab(self, parent):
        """创建配置管理选项卡"""
        # 配置操作区域
        config_ops_frame = ttk.LabelFrame(parent, text="配置操作", padding="10")
        config_ops_frame.pack(fill=tk.X, pady=(0, 10))

        ops_buttons = ttk.Frame(config_ops_frame)
        ops_buttons.pack(fill=tk.X)

        ttk.Button(ops_buttons, text="添加配置", command=self.add_config).pack(side=tk.LEFT, padx=2)
        ttk.Button(ops_buttons, text="编辑配置", command=self.edit_config).pack(side=tk.LEFT, padx=2)
        ttk.Button(ops_buttons, text="复制配置", command=self.duplicate_config).pack(side=tk.LEFT, padx=2)
        ttk.Button(ops_buttons, text="删除配置", command=self.delete_config).pack(side=tk.LEFT, padx=2)
        ttk.Button(ops_buttons, text="导入配置", command=self.import_configs).pack(side=tk.LEFT, padx=2)
        ttk.Button(ops_buttons, text="导出配置", command=self.export_configs).pack(side=tk.LEFT, padx=2)

        # 配置表格区域
        config_table_frame = ttk.LabelFrame(parent, text="输入项配置", padding="10")
        config_table_frame.pack(fill=tk.BOTH, expand=True)

        # 创建Treeview
        columns = ("序号", "启用", "输入方式", "Excel列名", "数据类型", "默认值", "对应记录点", "描述")
        self.config_treeview = ttk.Treeview(
            config_table_frame,
            columns=columns,
            show="headings",
            height=12
        )

        # 设置列
        column_configs = {
            "序号": {"width": 50, "anchor": "center"},
            "启用": {"width": 40, "anchor": "center"},
            "输入方式": {"width": 80, "anchor": "center"},
            "Excel列名": {"width": 120, "anchor": "center"},
            "数据类型": {"width": 80, "anchor": "center"},
            "默认值": {"width": 80, "anchor": "center"},
            "对应记录点": {"width": 80, "anchor": "center"},
            "描述": {"width": 150, "anchor": "w"}
        }

        for col in columns:
            self.config_treeview.heading(col, text=col)
            config = column_configs.get(col, {})
            self.config_treeview.column(col,
                                      width=config.get("width", 100),
                                      anchor=config.get("anchor", "w"))

        # 滚动条
        scrollbar = ttk.Scrollbar(config_table_frame, orient=tk.VERTICAL, command=self.config_treeview.yview)
        self.config_treeview.configure(yscrollcommand=scrollbar.set)

        # 布局
        self.config_treeview.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        # 绑定事件
        self.config_treeview.bind('<Double-1>', lambda e: self.edit_config())

    def create_preview_tab(self, parent):
        """创建数据预览选项卡"""
        # 预览控制区域
        preview_controls = ttk.LabelFrame(parent, text="预览控制", padding="10")
        preview_controls.pack(fill=tk.X, pady=(0, 10))

        controls_frame = ttk.Frame(preview_controls)
        controls_frame.pack(fill=tk.X)

        ttk.Label(controls_frame, text="预览行数:").pack(side=tk.LEFT)
        self.preview_rows_var = tk.StringVar(value="10")
        preview_spin = ttk.Spinbox(
            controls_frame,
            textvariable=self.preview_rows_var,
            from_=1, to=100, width=5
        )
        preview_spin.pack(side=tk.LEFT, padx=5)
        preview_spin.bind('<FocusOut>', self.update_preview)

        ttk.Label(controls_frame, text="显示模式:").pack(side=tk.LEFT, padx=(20, 5))
        self.preview_mode_var = tk.StringVar(value="processed")
        ttk.Radiobutton(controls_frame, text="处理数据", variable=self.preview_mode_var,
                       value="processed", command=self.update_preview).pack(side=tk.LEFT, padx=2)
        ttk.Radiobutton(controls_frame, text="原始数据", variable=self.preview_mode_var,
                       value="original", command=self.update_preview).pack(side=tk.LEFT, padx=2)

        ttk.Button(controls_frame, text="刷新预览", command=self.update_preview).pack(side=tk.RIGHT, padx=2)

        # 数据预览区域
        preview_frame = ttk.LabelFrame(parent, text="数据预览", padding="10")
        preview_frame.pack(fill=tk.BOTH, expand=True)

        # 创建Treeview用于预览
        self.preview_treeview = ttk.Treeview(
            preview_frame,
            columns=(),  # 动态设置
            show="headings",
            height=15
        )

        # 滚动条
        preview_scrollbar_x = ttk.Scrollbar(preview_frame, orient=tk.HORIZONTAL, command=self.preview_treeview.xview)
        preview_scrollbar_y = ttk.Scrollbar(preview_frame, orient=tk.VERTICAL, command=self.preview_treeview.yview)
        self.preview_treeview.configure(xscrollcommand=preview_scrollbar_x.set,
                                      yscrollcommand=preview_scrollbar_y.set)

        # 布局
        self.preview_treeview.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        preview_scrollbar_y.pack(side=tk.RIGHT, fill=tk.Y)
        preview_scrollbar_x.pack(side=tk.BOTTOM, fill=tk.X)

    def create_button_section(self, parent):
        """创建按钮区域 - 修复版本"""
        btn_frame = ttk.Frame(parent)
        btn_frame.pack(fill=tk.X, pady=(0, 10))

        # 主要操作按钮
        ttk.Button(btn_frame, text="处理数据", command=self.process_data).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="导出结果", command=self.export_results).pack(side=tk.LEFT, padx=2)
        ttk.Button(btn_frame, text="导入主程序", command=self.import_to_main).pack(side=tk.LEFT, padx=2)

        # 右侧按钮
        ttk.Button(btn_frame, text="保存配置", command=self.save_configs).pack(side=tk.RIGHT, padx=2)
        ttk.Button(btn_frame, text="重置配置", command=self.reset_configs).pack(side=tk.RIGHT, padx=2)
        ttk.Button(btn_frame, text="关闭", command=self.window.destroy).pack(side=tk.RIGHT, padx=2)

    def create_status_bar(self, parent):
        """创建状态栏"""
        self.status_var = tk.StringVar(value="就绪")
        status_bar = ttk.Label(
            parent,
            textvariable=self.status_var,
            relief=tk.SUNKEN,
            anchor=tk.W,
            padding=(5, 2)
        )
        status_bar.pack(fill=tk.X, side=tk.BOTTOM)

    def bind_events(self):
        """绑定事件"""
        # 窗口事件
        self.window.protocol("WM_DELETE_WINDOW", self.on_closing)

        # 快捷键
        self.window.bind('<Control-o>', lambda e: self.browse_file())
        self.window.bind('<Control-l>', lambda e: self.load_excel())
        self.window.bind('<Control-p>', lambda e: self.process_data())
        self.window.bind('<F1>', lambda e: self.show_help())

    def load_recent_files(self):
        """加载最近文件列表"""
        try:
            # 从主程序配置获取最近文件
            if hasattr(self.main_app, 'config') and 'recent_files' in self.main_app.config:
                recent_files = self.main_app.config['recent_files']

                # 更新组合框
                combo = self.window.nametowidget(self.recent_files_var._name)
                combo['values'] = recent_files

        except Exception as e:
            self.log_error(f"加载最近文件失败: {e}")

    def on_recent_file_selected(self, event):
        """最近文件选择事件"""
        file_path = self.recent_files_var.get()
        if file_path and os.path.exists(file_path):
            self.file_path_var.set(file_path)
            self.load_excel()

    def browse_file(self):
        """浏览文件 - 修复版本"""
        file_path = filedialog.askopenfilename(
            title="选择Excel文件",
            filetypes=[
                ("Excel文件", "*.xlsx *.xls"),
                ("CSV文件", "*.csv"),
                ("所有文件", "*.*")
            ]
        )
        if file_path:
            self.file_path_var.set(file_path)
            self.load_excel()

    def refresh_file(self):
        """刷新文件"""
        if self.file_path_var.get() and os.path.exists(self.file_path_var.get()):
            self.load_excel()
        else:
            self.show_warning("请先选择有效的Excel文件")

    def validate_file(self):
        """验证文件"""
        file_path = self.file_path_var.get()
        if not file_path:
            self.show_warning("请先选择Excel文件")
            return

        if not os.path.exists(file_path):
            self.show_error(f"文件不存在: {file_path}")
            return

        # 验证文件格式
        try:
            import pandas as pd
            # 尝试读取文件头信息
            pd.read_excel(file_path, nrows=1, engine='openpyxl')
            self.show_info("文件格式验证通过")
        except Exception as e:
            self.show_error(f"文件格式验证失败: {e}")

    def show_file_info(self):
        """显示文件信息"""
        if not self.excel_handler.df:
            self.show_warning("请先加载Excel文件")
            return

        stats = self.excel_handler.get_data_stats()

        info_text = f"""文件信息:
        
文件路径: {stats.get('file_path', '未知')}
工作表: {stats.get('current_sheet', '未知')}
总行数: {stats.get('total_rows', 0)}
总列数: {stats.get('total_columns', 0)}
处理行数: {stats.get('processed_rows', 0)}

可用工作表: {', '.join(stats.get('available_sheets', []))}

列信息:
"""
        for col in stats.get('column_names', []):
            info_text += f"  • {col}\n"

        # 显示列统计信息
        if 'column_statistics' in stats:
            info_text += "\n列统计:\n"
            for col, col_stats in stats['column_statistics'].items():
                info_text += f"  {col}: {col_stats['non_null_count']}非空, {col_stats['null_count']}空值\n"

        self.update_file_info(info_text)

    def update_file_info(self, info_text):
        """更新文件信息显示"""
        self.file_info_text.config(state=tk.NORMAL)
        self.file_info_text.delete(1.0, tk.END)
        self.file_info_text.insert(1.0, info_text)
        self.file_info_text.config(state=tk.DISABLED)

    def on_sheet_changed(self, event):
        """工作表改变事件"""
        if self.file_path_var.get() and self.sheet_var.get():
            self.load_excel()

    def on_header_row_changed(self, event=None):
        """表头行改变事件"""
        if self.file_path_var.get():
            # 重新加载文件，使用新的表头行
            self.load_excel()

    def load_excel(self):
        """加载Excel文件 - 修复版本"""
        file_path = self.file_path_var.get()
        if not file_path:
            self.show_warning("请先选择Excel文件")
            return

        try:
            # 获取设置
            sheet_name = self.sheet_var.get() or None
            header_row = int(self.header_row_var.get()) - 1  # 转换为0-based
            start_row = int(self.start_row_var.get()) - 1    # 转换为0-based

            # 加载Excel文件
            success, message = self.excel_handler.load_excel_file(
                file_path,
                sheet_name=sheet_name,
                start_row=start_row,
                header_row=header_row
            )

            if success:
                self.current_file_path = file_path
                self.column_names = self.excel_handler.get_column_names()

                # 更新工作表列表
                sheets = self.excel_handler.sheet_names
                self.sheet_combo['values'] = sheets
                if sheets and not self.sheet_var.get():
                    self.sheet_var.set(sheets[0])

                # 更新状态
                self.update_status(f"成功加载: {os.path.basename(file_path)}")

                # 更新文件信息
                stats = self.excel_handler.get_data_stats()
                info_text = f"文件: {os.path.basename(file_path)}\n"
                info_text += f"工作表: {stats.get('current_sheet', '未知')}\n"
                info_text += f"数据: {stats.get('total_rows', 0)}行 × {stats.get('total_columns', 0)}列\n"
                info_text += f"加载时间: {datetime.now().strftime('%H:%M:%S')}"
                self.update_file_info(info_text)

                # 更新预览
                self.update_preview()

                # 添加到最近文件
                self.add_to_recent_files(file_path)

            else:
                self.show_error(f"加载失败: {message}")

        except Exception as e:
            self.show_error(f"加载Excel文件时出错: {e}")

    def add_to_recent_files(self, file_path):
        """添加到最近文件列表"""
        try:
            if hasattr(self.main_app, 'config_manager'):
                config = self.main_app.config_manager.load_config()
                config = self.main_app.config_manager.update_recent_files(config, file_path)
                self.main_app.config_manager.save_config(config)

                # 更新最近文件列表
                self.load_recent_files()

        except Exception as e:
            self.log_error(f"添加到最近文件失败: {e}")

    def update_preview(self, event=None):
        """更新数据预览"""
        if not self.excel_handler.df:
            return

        try:
            # 清空现有预览
            for item in self.preview_treeview.get_children():
                self.preview_treeview.delete(item)

            # 获取预览数据
            preview_mode = self.preview_mode_var.get()
            preview_rows = int(self.preview_rows_var.get())

            if preview_mode == "processed" and self.excel_handler.processed_data:
                data = self.excel_handler.get_data_sample(preview_rows)
                columns = ["行号"] + [config['column_name'] for config in self.input_configs]
            else:
                data = self.excel_handler.get_original_data_sample(preview_rows)
                columns = ["行号"] + self.column_names

            # 配置Treeview列
            self.preview_treeview['columns'] = columns
            for col in columns:
                self.preview_treeview.heading(col, text=col)
                self.preview_treeview.column(col, width=100, anchor="w")

            # 添加数据
            for row_data in data:
                values = [row_data.get(col, "") for col in columns]
                self.preview_treeview.insert("", "end", values=values)

        except Exception as e:
            self.log_error(f"更新预览失败: {e}")

    def add_config(self):
        """添加配置 - 修复版本"""
        if not self.column_names:
            self.show_warning("请先加载Excel文件")
            return

        # 创建配置对话框
        dialog = ConfigDialog(self.window, self.column_names, self.input_configs)

        if dialog.result:
            self.input_configs.append(dialog.result)
            self.update_config_display()
            self.update_status("配置已添加")

    def edit_config(self):
        """编辑配置 - 修复版本"""
        selection = self.config_treeview.selection()
        if not selection:
            self.show_warning("请先选择一个配置项")
            return

        index = self.config_treeview.index(selection[0])
        if 0 <= index < len(self.input_configs):
            config = self.input_configs[index]

            # 创建编辑对话框
            dialog = ConfigDialog(self.window, self.column_names, self.input_configs, config)

            if dialog.result:
                self.input_configs[index] = dialog.result
                self.update_config_display()
                self.update_status("配置已更新")

    def duplicate_config(self):
        """复制配置"""
        selection = self.config_treeview.selection()
        if not selection:
            self.show_warning("请先选择一个配置项")
            return

        index = self.config_treeview.index(selection[0])
        if 0 <= index < len(self.input_configs):
            # 创建配置副本
            original_config = self.input_configs[index]
            duplicated_config = original_config.copy()
            duplicated_config['description'] = f"{duplicated_config.get('description', '')} (副本)"

            self.input_configs.insert(index + 1, duplicated_config)
            self.update_config_display()
            self.update_status("配置已复制")

    def delete_config(self):
        """删除配置 - 修复版本"""
        selection = self.config_treeview.selection()
        if not selection:
            self.show_warning("请先选择一个配置项")
            return

        # 确认删除
        if not messagebox.askyesno("确认删除", "确定要删除选中的配置项吗？"):
            return

        # 按索引从大到小删除，避免索引变化
        indices = sorted([self.config_treeview.index(item) for item in selection], reverse=True)

        for index in indices:
            if 0 <= index < len(self.input_configs):
                self.input_configs.pop(index)

        self.update_config_display()
        self.update_status(f"已删除 {len(indices)} 个配置项")

    def import_configs(self):
        """导入配置"""
        file_path = filedialog.askopenfilename(
            title="选择配置文件",
            filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")]
        )

        if file_path:
            try:
                import json
                with open(file_path, 'r', encoding='utf-8') as f:
                    imported_configs = json.load(f)

                if isinstance(imported_configs, list):
                    # 合并配置
                    self.input_configs.extend(imported_configs)
                    self.update_config_display()
                    self.show_info(f"已导入 {len(imported_configs)} 个配置项")
                else:
                    self.show_error("配置文件格式不正确")

            except Exception as e:
                self.show_error(f"导入配置失败: {e}")

    def export_configs(self):
        """导出配置"""
        if not self.input_configs:
            self.show_warning("没有配置可导出")
            return

        file_path = filedialog.asksaveasfilename(
            title="保存配置文件",
            defaultextension=".json",
            filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")]
        )

        if file_path:
            try:
                import json
                with open(file_path, 'w', encoding='utf-8') as f:
                    json.dump(self.input_configs, f, ensure_ascii=False, indent=2)

                self.show_info(f"配置已导出到: {file_path}")

            except Exception as e:
                self.show_error(f"导出配置失败: {e}")

    def save_configs(self):
        """保存配置到文件"""
        if not self.input_configs:
            self.show_warning("没有配置可保存")
            return

        # 这里可以实现将配置保存到特定文件或数据库
        self.show_info("配置已保存")

    def reset_configs(self):
        """重置配置"""
        if not self.input_configs:
            return

        if messagebox.askyesno("确认重置", "确定要重置所有配置吗？"):
            self.input_configs.clear()
            self.update_config_display()
            self.update_status("配置已重置")

    def update_config_display(self):
        """更新配置显示 - 修复版本"""
        # 清空现有显示
        for item in self.config_treeview.get_children():
            self.config_treeview.delete(item)

        # 添加所有配置
        for i, config in enumerate(self.input_configs):
            enabled = "✓" if config.get('enabled', True) else "✗"
            input_method = config.get('input_method', 'text')
            column_name = config.get('column_name', '')
            data_type = config.get('data_type', 'auto')
            default_value = str(config.get('default_value', ''))[:20]  # 截断长值
            point_index = config.get('point_index', '自动')
            description = config.get('description', '')[:30]  # 截断长描述

            self.config_treeview.insert(
                "", "end",
                values=(
                    i + 1,
                    enabled,
                    input_method,
                    column_name,
                    data_type,
                    default_value,
                    point_index,
                    description
                )
            )

    def process_data(self):
        """处理数据 - 修复版本"""
        if not self.excel_handler.df:
            self.show_warning("请先加载Excel文件")
            return

        if not self.input_configs:
            self.show_warning("请先配置输入项")
            return

        try:
            # 获取开始行
            start_row = int(self.start_row_var.get()) - 1  # 转换为0-based

            # 处理数据
            success, message = self.excel_handler.process_data(
                self.input_configs,
                start_row=start_row
            )

            if success:
                self.update_status(message)
                self.update_preview()

                # 显示处理统计
                stats = self.excel_handler.get_data_stats()
                processed_count = stats.get('processed_rows', 0)
                self.show_info(f"数据处理完成: {processed_count} 行数据已处理")
            else:
                self.show_error(f"处理失败: {message}")

        except Exception as e:
            self.show_error(f"处理数据时出错: {e}")

    def export_results(self):
        """导出结果 - 修复版本"""
        if not self.excel_handler.processed_data:
            self.show_warning("没有处理后的数据可导出")
            return

        file_path = filedialog.asksaveasfilename(
            title="保存处理结果",
            defaultextension=".xlsx",
            filetypes=[
                ("Excel文件", "*.xlsx"),
                ("CSV文件", "*.csv"),
                ("所有文件", "*.*")
            ]
        )

        if file_path:
            try:
                if file_path.endswith('.csv'):
                    success, message = self.excel_handler.export_to_csv(file_path, self.input_configs)
                else:
                    success, message = self.excel_handler.save_processed_data(file_path, self.input_configs)

                if success:
                    self.show_info(message)
                else:
                    self.show_error(message)

            except Exception as e:
                self.show_error(f"导出结果失败: {e}")

    def import_to_main(self):
        """导入数据到主程序 - 修复版本"""
        if not hasattr(self.main_app, 'set_excel_data'):
            self.show_error("主程序不支持Excel数据导入")
            return

        if not self.input_configs:
            self.show_warning("请先配置输入项")
            return

        if not self.excel_handler.processed_data:
            self.show_warning("请先处理数据")
            return

        try:
            # 构建导入数据
            import_data = {
                'configs': self.input_configs,
                'data': self.excel_handler.processed_data,
                'file_info': {
                    'path': self.current_file_path,
                    'sheet': self.excel_handler.current_sheet,
                    'processed_time': datetime.now().isoformat()
                }
            }

            # 调用主程序的导入方法
            if hasattr(self.main_app, 'set_excel_data'):
                self.main_app.set_excel_data(import_data)
                self.show_info("数据已成功导入到主程序")
            else:
                self.show_error("主程序没有实现数据导入接口")

        except Exception as e:
            self.show_error(f"导入到主程序失败: {e}")

    def show_help(self):
        """显示帮助信息"""
        help_text = """Excel工具 - 使用说明

数据导入:
1. 选择Excel文件或从最近文件列表中选择
2. 选择工作表和数据起始行
3. 点击"加载Excel"导入数据

配置管理:
1. 点击"添加配置"创建新的输入项配置
2. 双击配置项进行编辑
3. 使用启用/禁用控制配置项是否生效

数据处理:
1. 配置完所有输入项后点击"处理数据"
2. 在数据预览选项卡查看处理结果
3. 使用"导出结果"保存处理后的数据

导入主程序:
1. 处理数据后点击"导入主程序"
2. 数据将传输到主程序供自动化使用

快捷键:
• Ctrl+O: 打开文件
• Ctrl+L: 加载Excel
• Ctrl+P: 处理数据
• F1: 显示帮助
"""
        self.show_info(help_text, "使用帮助")

    def update_status(self, message):
        """更新状态"""
        self.status_var.set(message)

    def log_error(self, message):
        """记录错误"""
        self.update_status(f"错误: {message}")
        # 这里可以添加日志记录

    def show_info(self, message, title="信息"):
        """显示信息对话框"""
        messagebox.showinfo(title, message, parent=self.window)

    def show_warning(self, message, title="警告"):
        """显示警告对话框"""
        messagebox.showwarning(title, message, parent=self.window)

    def show_error(self, message, title="错误"):
        """显示错误对话框"""
        messagebox.showerror(title, message, parent=self.window)

    def on_closing(self):
        """窗口关闭事件"""
        try:
            # 清理资源
            self.excel_handler.clear_data()
            self.window.destroy()
        except Exception as e:
            self.log_error(f"关闭窗口时出错: {e}")
            self.window.destroy()